package pl.poznan.put.cs.idss.particlefilter.utils;

// Found at <http://javatechniques.com/blog/faster-deep-copies-of-java-objects/>.
// Read on 10/19/2010.  Author: Philip Isenhour 
//
// Adapted (and modified) on 10/2010 by Wayne Pollock, Tampa Florida USA

import java.io.*;
import java.util.*;

/**
 * Utility for making deep copies (vs. clone()'s shallow copies) of
 * objects. Objects are first serialized and then deserialized. Error
 * checking is fairly minimal in this implementation. If an object is
 * encountered that cannot be serialized (or that references an object
 * that cannot be serialized) an error is printed to System.err and
 * null is returned. Depending on your specific application, it might
 * make more sense to re-throw the (caught) exception.
 */

public class DeepCopy {

    /**
     * Returns a copy of the object, or null if the object cannot
     * be serialized.
     */
    public static Object copy ( Object orig ) {
        Object obj = null;
        try {
            // Write the object out to a byte array:
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(bos);
            out.writeObject(orig);
            out.flush();
            out.close();

            // Make an input stream from the byte array and read
            // a copy of the object back in:
            ObjectInputStream in = new ObjectInputStream(
                new ByteArrayInputStream(bos.toByteArray()));
            obj = in.readObject();
        }
        catch(IOException e) {
            e.printStackTrace();
        }
        catch(ClassNotFoundException cnfe) {
            cnfe.printStackTrace();
        }
        return obj;
    }

}